// 全局变量
let currentUser = null;
let currentConversationId = 1; // 默认对话ID

// 初始化
document.addEventListener('DOMContentLoaded', function() {
    console.log('DOM 内容已加载，开始初始化...');
    initializeEventListeners();
    loadPreUploadedFiles();
    checkUserLoginStatus();
});

// 初始化事件监听器
function initializeEventListeners() {
    console.log('正在初始化事件监听器...');
    // 聊天功能
    const sendButton = document.getElementById('sendButton');
    const messageInput = document.getElementById('messageInput');
    const clearHistoryButton = document.getElementById('clearHistoryButton');
    const newConversationButton = document.getElementById('newConversationButton');
    
    if (sendButton) sendButton.addEventListener('click', sendMessage);
    if (messageInput) messageInput.addEventListener('keypress', function(e) {
        if (e.key === 'Enter' && !e.shiftKey) {
            e.preventDefault();
            sendMessage();
        }
    });
    
    // 清空历史记录按钮
    if (clearHistoryButton) clearHistoryButton.addEventListener('click', clearHistory);
    
    // 新建对话按钮
    if (newConversationButton) newConversationButton.addEventListener('click', createNewConversation);
    
    // 登录注册功能
    const loginButton = document.getElementById('loginButton');
    const registerButton = document.getElementById('registerButton');
    const logoutButton = document.getElementById('logoutButton');
    const loginModal = document.getElementById('loginModal');
    const registerModal = document.getElementById('registerModal');
    const closeButtons = document.querySelectorAll('.close');
    const switchToRegister = document.getElementById('switchToRegister');
    const switchToLogin = document.getElementById('switchToLogin');
    const promptLoginButton = document.getElementById('promptLoginButton');
    const promptRegisterButton = document.getElementById('promptRegisterButton');
    
    // 打开模态框
    loginButton.addEventListener('click', () => openModal(loginModal));
    registerButton.addEventListener('click', () => openModal(registerModal));
    promptLoginButton.addEventListener('click', () => openModal(loginModal));
    promptRegisterButton.addEventListener('click', () => openModal(registerModal));
    
    // 关闭模态框
    closeButtons.forEach(button => {
        button.addEventListener('click', () => {
            closeModal(loginModal);
            closeModal(registerModal);
        });
    });
    
    // 切换表单
    switchToRegister?.addEventListener('click', () => {
        closeModal(loginModal);
        openModal(registerModal);
    });
    
    switchToLogin?.addEventListener('click', () => {
        closeModal(registerModal);
        openModal(loginModal);
    });
    
    // 登出按钮
    logoutButton?.addEventListener('click', logout);
    
    // 点击模态框外部关闭
    window.addEventListener('click', (event) => {
        if (event.target === loginModal) closeModal(loginModal);
        if (event.target === registerModal) closeModal(registerModal);
    });
    
    // 登录表单提交
    const loginForm = document.getElementById('loginForm');
    if (loginForm) loginForm.addEventListener('submit', function(e) {
        e.preventDefault();
        handleLogin();
    });
    
    // 注册表单提交
    const registerForm = document.getElementById('registerForm');
    if (registerForm) registerForm.addEventListener('submit', function(e) {
        e.preventDefault();
        handleRegister();
    });
}

// 打开模态框
function openModal(modal) {
    if (modal) modal.style.display = 'block';
}

// 关闭模态框
function closeModal(modal) {
    if (modal) modal.style.display = 'none';
}

// 检查用户登录状态
function checkUserLoginStatus() {
    console.log('正在检查用户登录状态...');
    const token = localStorage.getItem('token');
    const userInfo = localStorage.getItem('userInfo');
    
    if (token && userInfo) {
        try {
            currentUser = JSON.parse(userInfo);
            console.log('用户已登录:', currentUser);
            updateUIForLoggedInUser();
            loadUserChatHistory(); // 修复：调用正确的函数名
        } catch (error) {
            console.error('用户信息解析失败:', error);
            localStorage.removeItem('token');
            localStorage.removeItem('userInfo');
        }
    } else {
        console.log('用户未登录');
    }
}

// 创建新对话
function createNewConversation() {
    const token = localStorage.getItem('token');
    if (!token) {
        alert('请先登录');
        return;
    }
    
    // 向后端发送请求创建新对话
    fetch('/api/create-conversation', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${token}`
        },
        body: JSON.stringify({
            title: '新对话'
        })
    })
    .then(response => {
        if (!response.ok) {
            throw new Error('创建新对话失败');
        }
        return response.json();
    })
    .then(data => {
        // 更新当前对话ID
        currentConversationId = data.conversation_id;
        
        // 清空聊天界面和输入框
        const chatMessages = document.getElementById('chatMessages');
        chatMessages.innerHTML = '';
        
        // 添加欢迎消息
        addMessage('您好！我是您的计算机网络课程AI助教。我可以帮助您：\n- 回答课程相关问题\n- 提供课本和视频的具体参考位置\n- 分析您的学习情况\n- 推荐相关学习资源\n\n请随时向我提问！', 'ai');
        
        // 清空输入框
        document.getElementById('messageInput').value = '';
        
        // 重新加载对话列表，显示新对话
        loadUserConversations();
    })
    .catch(error => {
        console.error('创建新对话失败:', error);
        alert('创建新对话失败，请稍后再试');
    });
}

// 删除对话
function deleteConversation(conversationId, element) {
    if (!confirm('确定要删除这个对话吗？此操作不可恢复。')) {
        return;
    }
    
    const token = localStorage.getItem('token');
    if (!token) {
        alert('请先登录');
        return;
    }
    
    fetch(`/api/conversation/${conversationId}`, {
        method: 'DELETE',
        headers: {
            'Authorization': `Bearer ${token}`,
            'Content-Type': 'application/json'
        }
    })
    .then(response => {
        if (!response.ok) {
            throw new Error('删除对话失败');
        }
        return response.json();
    })
    .then(data => {
        // 从DOM中移除元素
        if (element && element.parentNode) {
            element.parentNode.removeChild(element);
        }
        
        // 如果删除的是当前选中的对话，清空聊天界面
        if (conversationId === currentConversationId) {
            const chatMessages = document.getElementById('chatMessages');
            chatMessages.innerHTML = '';
            
            // 添加欢迎消息
            addMessage('您好！我是您的计算机网络课程AI助教。我可以帮助您：\n- 回答课程相关问题\n- 提供课本和视频的具体参考位置\n- 分析您的学习情况\n- 推荐相关学习资源\n\n请随时向我提问！', 'ai');
            
            // 重置当前对话ID
            currentConversationId = 1;
        }
        
        // 检查是否还有对话
        const historyItems = document.querySelectorAll('.history-item');
        if (historyItems.length === 0) {
            document.getElementById('historyList').innerHTML = '<div class="no-history">暂无问题记录</div>';
        }
    })
    .catch(error => {
        console.error('删除对话失败:', error);
        alert('删除对话失败，请稍后再试');
    });
}

// 更新对话时间戳
function updateConversationTimestamp() {
    // 简单实现：仅更新当前对话的时间戳，不重新加载整个列表
    // 实际应用中应该调用API更新服务器上的时间戳
    
    // 获取当前选中的历史记录项
    const selectedItem = document.querySelector('.history-item.selected');
    if (selectedItem) {
        // 更新时间戳显示
        const now = new Date();
        const formattedTime = now.toLocaleTimeString('zh-CN', {
            hour: '2-digit',
            minute: '2-digit'
        });
        
        const timeElement = selectedItem.querySelector('.history-item-time');
        if (timeElement) {
            timeElement.textContent = formattedTime;
        }
        
        // 将当前对话移到列表顶部
        const historyList = document.getElementById('historyList');
        historyList.insertBefore(selectedItem, historyList.firstChild);
    }
}

// 加载用户对话列表
function loadUserConversations() {
    // 实际应用中应该调用API获取用户的对话列表
    // 这里简化实现，直接调用loadUserChatHistory
    loadUserChatHistory();
}

// 处理登录
function handleLogin() {
    const username = document.getElementById('loginUsername').value;
    const password = document.getElementById('loginPassword').value;
    
    if (!username || !password) {
        alert('请输入用户名和密码');
        return;
    }
    
    fetch('/api/login', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({ username: username, password: password })
    })
    .then(response => {
        if (!response.ok) {
            throw new Error('登录失败');
        }
        return response.json();
    })
    .then(data => {
        // 保存令牌和用户信息
        localStorage.setItem('token', data.access_token);
        
        // 创建用户信息对象（不包含密码）
        const userInfo = {
            id: data.user_id,
            name: data.name,
            username: username
        };
        
        localStorage.setItem('userInfo', JSON.stringify(userInfo));
        currentUser = userInfo;
        
        // 更新UI
        updateUIForLoggedInUser();
        
        // 加载用户对话
        loadUserConversations();
        
        // 关闭登录模态框
        closeModal(document.getElementById('loginModal'));
    })
    .catch(error => {
        console.error('登录失败:', error);
        alert('登录失败，请检查用户名和密码');
    });
}

// 处理注册
function handleRegister() {
    const username = document.getElementById('registerUsername').value;
    const password = document.getElementById('registerPassword').value;
    const name = document.getElementById('registerName').value;
    
    if (!username || !password || !name) {
        alert('请填写完整信息');
        return;
    }
    
    fetch('/api/register', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json'
        },
        body: JSON.stringify({ username: username, password: password, name: name })
    })
    .then(response => {
        if (!response.ok) {
            throw new Error('注册失败');
        }
        return response.json();
    })
    .then(() => {
        alert('注册成功，请登录');
        closeModal(document.getElementById('registerModal'));
        openModal(document.getElementById('loginModal'));
    })
    .catch(error => {
        console.error('注册失败:', error);
        alert('注册失败，用户名可能已被使用');
    });
}

// 更新登录后的UI
function updateUIForLoggedInUser() {
    document.getElementById('loginButton').style.display = 'none';
    document.getElementById('registerButton').style.display = 'none';
    document.getElementById('userInfo').style.display = 'flex';
    document.getElementById('userName').textContent = currentUser.name;
    
    document.getElementById('notLoggedIn').style.display = 'none';
    document.getElementById('chatWrapper').style.display = 'flex';
    document.getElementById('chatWrapper').style.flexDirection = 'column';
}

// 更新未登录的UI
function updateUIForLoggedOutUser() {
    document.getElementById('loginButton').style.display = 'block';
    document.getElementById('registerButton').style.display = 'block';
    document.getElementById('userInfo').style.display = 'none';
    
    document.getElementById('notLoggedIn').style.display = 'flex';
    document.getElementById('chatWrapper').style.display = 'none';
    
    // 清空聊天记录
    document.getElementById('chatMessages').innerHTML = '';
}

// 登出
function logout() {
    // 清除localStorage
    localStorage.removeItem('token');
    localStorage.removeItem('userInfo');
    currentUser = null;
    currentConversationId = 1; // 重置对话ID
    
    // 更新UI
    updateUIForLoggedOutUser();
}

// 加载用户对话列表
function loadUserConversations() {
    const token = localStorage.getItem('token');
    if (!token) return;
    
    // 获取所有对话
    fetch('/api/conversations', {
        method: 'GET',
        headers: {
            'Authorization': `Bearer ${token}`,
            'Content-Type': 'application/json'
        }
    })
    .then(response => {
        if (!response.ok) {
            throw new Error('加载对话列表失败');
        }
        return response.json();
    })
    .then(data => {
        // 清空历史记录面板
        const historyList = document.getElementById('historyList');
        historyList.innerHTML = '';
        
        // 显示对话列表
        if (data.conversations && data.conversations.length > 0) {
            data.conversations.forEach((conversation, index) => {
                addConversationToHistoryPanel(conversation, index);
            });
            
            // 如果没有当前选中的对话，默认显示第一个
            if (!document.querySelector('.history-item.selected')) {
                const firstItem = document.querySelector('.history-item');
                if (firstItem) {
                    firstItem.click();
                }
            }
        } else {
            // 显示暂无历史记录
            historyList.innerHTML = '<div class="no-history">暂无问题记录</div>';
        }
    })
    .catch(error => {
        console.error('加载对话列表失败:', error);
        document.getElementById('historyList').innerHTML = '<div class="no-history">加载对话列表失败</div>';
    });
}

// 添加对话到历史面板
function addConversationToHistoryPanel(conversation, index) {
    const historyList = document.getElementById('historyList');
    
    // 检查是否显示"暂无问题记录"并移除
    const noHistoryElement = historyList.querySelector('.no-history');
    if (noHistoryElement) {
        historyList.innerHTML = '';
    }
    
    const historyItem = document.createElement('div');
    historyItem.className = 'history-item';
    historyItem.dataset.conversationId = conversation.id;
    
    // 格式化时间
    const timestamp = new Date(conversation.updated_at * 1000);
    const formattedTime = timestamp.toLocaleTimeString('zh-CN', {
        hour: '2-digit',
        minute: '2-digit'
    });
    
    // 设置对话标题
    const title = conversation.title || '未命名对话';
    
    historyItem.innerHTML = `
        <div class="history-item-content">${title}</div>
        <div class="history-item-time">${formattedTime}</div>
        <button class="delete-conversation-btn" title="删除对话">×</button>
    `;
    
    // 添加点击事件
    historyItem.addEventListener('click', (e) => {
        // 如果点击的是删除按钮，不加载消息
        if (e.target.classList.contains('delete-conversation-btn')) {
            return;
        }
        loadConversationMessages(conversation.id);
        
        // 移除其他项的选中状态
        document.querySelectorAll('.history-item').forEach(item => {
            item.classList.remove('selected');
        });
        // 添加当前项的选中状态
        historyItem.classList.add('selected');
        
        // 更新当前对话ID
        currentConversationId = conversation.id;
    });
    
    // 添加删除按钮事件
    const deleteBtn = historyItem.querySelector('.delete-conversation-btn');
    deleteBtn.addEventListener('click', (e) => {
        e.stopPropagation(); // 阻止事件冒泡
        deleteConversation(conversation.id, historyItem);
    });
    
    historyList.appendChild(historyItem);
    
    // 滚动到底部，显示最新的记录
    historyList.scrollTop = historyList.scrollHeight;
}

// 加载特定对话的消息
function loadConversationMessages(conversationId) {
    const token = localStorage.getItem('token');
    if (!token) return;
    
    fetch(`/api/conversation/${conversationId}/messages`, {
        method: 'GET',
        headers: {
            'Authorization': `Bearer ${token}`,
            'Content-Type': 'application/json'
        }
    })
    .then(response => {
        if (!response.ok) {
            throw new Error('加载对话消息失败');
        }
        return response.json();
    })
    .then(data => {
        // 清空现有聊天记录
        const chatMessages = document.getElementById('chatMessages');
        chatMessages.innerHTML = '';
        
        // 添加欢迎消息
        addMessage('您好！我是您的计算机网络课程AI助教。我可以帮助您：\n- 回答课程相关问题\n- 提供课本和视频的具体参考位置\n- 分析您的学习情况\n- 推荐相关学习资源\n\n请随时向我提问！', 'ai');
        
        // 添加当前对话的历史消息到聊天界面
        if (data.messages && data.messages.length > 0) {
            data.messages.forEach(chat => {
                // 添加到聊天界面
                addMessage(chat.message, 'user');
                addMessage(chat.ai, 'ai');
            });
        }
    })
    .catch(error => {
        console.error('加载对话消息失败:', error);
    });
}

// 加载用户聊天历史 - 向后兼容
function loadUserChatHistory() {
    loadUserConversations();
}

// 添加聊天记录到历史面板
function addToHistoryPanel(chat, index) {
    const historyList = document.getElementById('historyList');
    
    // 检查是否显示"暂无问题记录"并移除
    const noHistoryElement = historyList.querySelector('.no-history');
    if (noHistoryElement) {
        historyList.innerHTML = '';
    }
    
    const historyItem = document.createElement('div');
    historyItem.className = 'history-item';
    historyItem.dataset.index = index;
    
    // 格式化时间
    const timestamp = new Date(chat.timestamp * 1000);
    const formattedTime = timestamp.toLocaleTimeString('zh-CN', {
        hour: '2-digit',
        minute: '2-digit'
    });
    
    // 限制问题内容长度
    const truncatedMessage = chat.message.length > 50 ? chat.message.substring(0, 50) + '...' : chat.message;
    
    historyItem.innerHTML = `
        <div class="history-item-content">${truncatedMessage}</div>
        <div class="history-item-time">${formattedTime}</div>
    `;
    
    // 添加点击事件
    historyItem.addEventListener('click', () => {
        showChatMessageByIndex(index);
        // 移除其他项的选中状态
        document.querySelectorAll('.history-item').forEach(item => {
            item.classList.remove('selected');
        });
        // 添加当前项的选中状态
        historyItem.classList.add('selected');
    });
    
    historyList.appendChild(historyItem);
    
    // 滚动到底部，显示最新的记录
    historyList.scrollTop = historyList.scrollHeight;
}

// 根据索引显示特定的聊天消息
function showChatMessageByIndex(index) {
    const messages = document.querySelectorAll('.message');
    // 跳过欢迎消息（索引0）
    const userMessageIndex = index * 2 + 1;
    const aiMessageIndex = userMessageIndex + 1;
    
    if (messages[userMessageIndex]) {
        // 滚动到用户消息位置
        messages[userMessageIndex].scrollIntoView({ behavior: 'smooth', block: 'center' });
    }
}

// 清空历史记录
function clearHistory() {
    if (confirm('确定要清空所有问题记录吗？此操作不可恢复。')) {
        const token = localStorage.getItem('token');
        if (token) {
            fetch('/api/clear-history', {
                method: 'POST',
                headers: {
                    'Authorization': `Bearer ${token}`,
                    'Content-Type': 'application/json'
                }
            })
            .then(response => {
                if (!response.ok) {
                    throw new Error('清空历史记录失败');
                }
                // 重新加载聊天历史
                loadUserChatHistory();
            })
            .catch(error => {
                console.error('清空历史记录失败:', error);
                alert('清空历史记录失败，请稍后再试。');
            });
        }
    }
}

// 发送消息
function sendMessage() {
    const messageInput = document.getElementById('messageInput');
    const message = messageInput.value.trim();
    const token = localStorage.getItem('token');
    
    if (!message) return;
    
    if (!token) {
        alert('请先登录');
        return;
    }
    
    // 检查是否需要创建新对话（如果当前对话ID为默认值1）
    if (currentConversationId === 1) {
        // 创建新对话并设置标题为第一条消息
        createNewConversationWithMessage(message);
        return;
    }
    
    addMessage(message, 'user');
    messageInput.value = '';
    
    // 使用fetch API调用REST API，带上认证令牌
    fetch('/api/chat', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${token}`
        },
        body: JSON.stringify({ 
            message: message,
            conversation_id: currentConversationId // 添加对话ID
        })
    })
    .then(response => {
        if (!response.ok) {
            if (response.status === 401) {
                // 认证失败，登出用户
                logout();
                throw new Error('认证失败，请重新登录');
            }
            throw new Error('无法获取回答');
        }
        return response.json();
    })
    .then(data => {
        addMessage(data.response, 'ai');
        
        // 更新对话时间戳并移至顶部
        updateConversationTimestamp();
        
        // 检查是否是新对话的第一条消息，如果是则更新对话标题
        if (document.querySelectorAll('.message').length <= 3) { // 欢迎消息 + 用户第一条消息 + AI第一条消息
            updateConversationTitle(message);
        }
    })
    .catch(error => {
        console.error('Error:', error);
        addMessage('抱歉，无法获取回答。请稍后再试。', 'ai');
    });
}

// 更新对话标题
function updateConversationTitle(message) {
    const token = localStorage.getItem('token');
    if (!token) return;
    
    // 截取消息前20个字符作为标题
    const title = message.substring(0, 20) + (message.length > 20 ? '...' : '');
    
    // 发送请求更新对话标题
    fetch(`/api/conversation/${currentConversationId}/title`, {
        method: 'PUT',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${token}`
        },
        body: JSON.stringify({ title: title })
    })
    .then(response => {
        if (!response.ok) {
            throw new Error('更新对话标题失败');
        }
        return response.json();
    })
    .then(() => {
        // 更新前端显示
        const selectedItem = document.querySelector(`.history-item[data-conversation-id="${currentConversationId}"]`);
        if (selectedItem) {
            const contentElement = selectedItem.querySelector('.history-item-content');
            if (contentElement) {
                contentElement.textContent = title;
            }
        }
    })
    .catch(error => {
        console.error('更新对话标题失败:', error);
    });
}

// 创建新对话并发送第一条消息
function createNewConversationWithMessage(message) {
    const token = localStorage.getItem('token');
    if (!token) return;
    
    // 截取消息前20个字符作为标题
    const title = message.substring(0, 20) + (message.length > 20 ? '...' : '');
    
    // 向后端发送请求创建新对话
    fetch('/api/create-conversation', {
        method: 'POST',
        headers: {
            'Content-Type': 'application/json',
            'Authorization': `Bearer ${token}`
        },
        body: JSON.stringify({ title: title })
    })
    .then(response => {
        if (!response.ok) {
            throw new Error('创建新对话失败');
        }
        return response.json();
    })
    .then(data => {
        // 更新当前对话ID
        currentConversationId = data.conversation_id;
        
        // 清空聊天界面
        const chatMessages = document.getElementById('chatMessages');
        chatMessages.innerHTML = '';
        
        // 添加欢迎消息
        addMessage('您好！我是您的计算机网络课程AI助教。我可以帮助您：\n- 回答课程相关问题\n- 提供课本和视频的具体参考位置\n- 分析您的学习情况\n- 推荐相关学习资源\n\n请随时向我提问！', 'ai');
        
        // 添加用户消息
        addMessage(message, 'user');
        
        // 发送用户消息到后端获取AI回复
        return fetch('/api/chat', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${token}`
            },
            body: JSON.stringify({ 
                message: message,
                conversation_id: currentConversationId 
            })
        });
    })
    .then(response => {
        if (!response.ok) {
            throw new Error('无法获取回答');
        }
        return response.json();
    })
    .then(data => {
        addMessage(data.response, 'ai');
        
        // 更新对话时间戳并移至顶部
        updateConversationTimestamp();
        
        // 重新加载对话列表，显示新对话和消息
        loadUserConversations();
        
        // 清空输入框
        document.getElementById('messageInput').value = '';
    })
    .catch(error => {
        console.error('Error:', error);
        addMessage('抱歉，无法获取回答。请稍后再试。', 'ai');
    });
}

// 添加消息到聊天框
function addMessage(content, type) {
    const chatMessages = document.getElementById('chatMessages');
    const messageDiv = document.createElement('div');
    messageDiv.className = `message ${type}-message`;
    
    const messageContent = document.createElement('div');
    messageContent.className = 'message-content';
    
    // 处理消息内容，支持换行和链接
    const formattedContent = formatMessage(content);
    messageContent.innerHTML = formattedContent;
    
    messageDiv.appendChild(messageContent);
    chatMessages.appendChild(messageDiv);
    
    // 滚动到底部
    chatMessages.scrollTop = chatMessages.scrollHeight;
}

// 格式化消息内容
function formatMessage(content) {
    // 将换行符转换为HTML
    let formatted = content.replace(/\n/g, '<br>');
    
    // 高亮页码引用
    formatted = formatted.replace(/第(\d+)页到第(\d+)页/g, 
        '<span class="page-reference" onclick="goToPage($1, $2)">第$1页到第$2页</span>');
    
    // 高亮视频时间引用
    formatted = formatted.replace(/第(\d+)章第(\d+)分钟到第(\d+)分钟/g, 
        '<span class="video-reference" onclick="goToVideo($1, $2, $3)">第$1章第$2分钟到第$3分钟</span>');
    
    return formatted;
}

// 跳转到指定页码
function goToPage(startPage, endPage) {
    // 这里可以打开PDF阅读器并跳转到指定页面
    window.open(`/public/textbook.html?page=${startPage}`, '_blank');
}

// 跳转到指定视频时间
function goToVideo(chapter, startTime, endTime) {
    // 这里可以打开视频播放器并跳转到指定时间
    window.open(`/public/video.html?chapter=${chapter}&start=${startTime}&end=${endTime}`, '_blank');
}

// 打开课本
function openTextbook(filePath) {
    window.open(`/public/textbook.html?file=${encodeURIComponent(filePath)}`, '_blank');
}

// 打开视频
function openVideo(filePath) {
    window.open(`/public/video.html?file=${encodeURIComponent(filePath)}`, '_blank');
}

// 加载预上传的文件
function loadPreUploadedFiles() {
    console.log('正在加载预上传的文件...');
    
    // 设置超时的fetch函数
    function fetchWithTimeout(resource, options = {}, timeout = 5000) {
        return Promise.race([
            fetch(resource, options),
            new Promise((_, reject) => 
                setTimeout(() => reject(new Error(`请求超时: ${resource}`)), timeout)
            )
        ]);
    }
    
    // 加载课本文件列表
    fetchWithTimeout('/api/files/textbooks')
        .then(response => {
            console.log('课本API响应状态:', response.status);
            if (!response.ok) {
                throw new Error(`课本API响应错误: ${response.status}`);
            }
            return response.json();
        })
        .then(files => {
            console.log('获取到课本文件列表，数量:', files.length);
            updateTextbookList(files);
        })
        .catch(error => {
            console.error('加载课本时出错:', error);
            updateTextbookList([]);
        });
    
    // 加载视频文件列表
    fetchWithTimeout('/api/files/videos')
        .then(response => {
            console.log('视频API响应状态:', response.status);
            if (!response.ok) {
                throw new Error(`视频API响应错误: ${response.status}`);
            }
            return response.json();
        })
        .then(files => {
            console.log('获取到视频文件列表，数量:', files.length);
            updateVideoList(files);
        })
        .catch(error => {
            console.error('加载视频时出错:', error);
            updateVideoList([]);
        });
}

// 更新课本列表
function updateTextbookList(files) {
    console.log('正在更新课本列表...');
    const textbookList = document.getElementById('textbookList');
    
    if (!textbookList) {
        console.error('未找到textbookList元素');
        return;
    }
    
    textbookList.innerHTML = files.map(file => {
        const icon = file.type === 'textbook' ? '📚' : '📖';
        const status = file.type === 'textbook' ? '主要教材' : '辅助资料';
        const size = (file.size / 1024 / 1024).toFixed(2);
        
        return `
            <div class="textbook-item">
                <div class="textbook-icon">${icon}</div>
                <div class="textbook-info">
                    <h3>${file.name}</h3>
                    <p>大小: ${size} MB</p>
                    <span class="textbook-status">${status}</span>
                </div>
                <button class="read-btn" onclick="openTextbook('${file.path}')">阅读</button>
            </div>
        `;
    }).join('');
}

// 更新视频列表
function updateVideoList(files) {
    console.log('正在更新视频列表...');
    const videoGrid = document.getElementById('videoGrid');
    
    if (!videoGrid) {
        console.error('未找到videoGrid元素');
        return;
    }
    
    videoGrid.innerHTML = files.map(file => {
        const size = (file.size / 1024 / 1024).toFixed(2);
        
        return `
            <div class="video-card">
                <div class="video-thumbnail">
                    <div class="play-icon">▶</div>
                </div>
                <div class="video-info">
                    <h3>${file.name}</h3>
                    <p>大小: ${size} MB</p>
                    <span class="video-status">已上传</span>
                </div>
                <button class="watch-btn" onclick="openVideo('${file.path}')">观看</button>
            </div>
        `;
    }).join('');
}

// 全局错误处理
window.addEventListener('error', function(event) {
    console.error('JavaScript错误:', event.error);
    console.error('错误位置:', event.filename, '行:', event.lineno, '列:', event.colno);
});

window.addEventListener('unhandledrejection', function(event) {
    console.error('未处理的Promise拒绝:', event.reason);
});
